/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package administracion.helper;

import administracion.delegate.GestionPedidosDelegate;
import administracion.delegate.GestionSeguridadDelegate;
import administracion.propiedades.Propiedades;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import seguridad.administracion.ejb30.TO.DatosUsuarioTO;
import seguridad.administracion.ejb30.TO.DescripcionTiposTO;
import seguridad.administracion.ejb30.TO.DetalleUsuarioSistemaTO;
import seguridad.administracion.ejb30.TO.FuncionRolTO;
import seguridad.administracion.ejb30.TO.FuncionesAccessoUsuarioTO;
import seguridad.administracion.ejb30.TO.SistemaTO;
import seguridad.administracion.ejb30.TO.TipoDatoTO;
import suministros.ejb30.TO.*;
import suministros.ejb30.entity.Parametros;
import suministros.ejb30.TO.SubAlmacenTO;

/**
 *
 * @author Renato
 */
public class Listas {
  private static List<ZonaTO> zonas;
  private static List<LocalidadTO> localidades;
  private static List<UnidadOrganizativaTO> un_organizativa;
  private static List<CentroCostoTO> centro_costos;
  private static List<CodPresupuestalTO> cod_presupuestal;
  private static List<CuentaContableTO> cta_ctbles;
  private static List<CodigosInversionTO> cod_inversion;
  private static List<TipoTO> tipos;
  private static List<Parametros> parametros;
  private static List<SuministroTO> suministros;
  private static List<GrupoSuministrosTO> gruposuministros;
  private static List<AnoTO> anos;
  private static List<MesTO> meses;
  private static List<AnoTO> anos_cambio;
  private static List<MesTO> meses_cambio;
  private static List<DetalleUsuarioSistemaTO> detallesUsuSistema;
  private static List<ProyectoTO> proyectos;
  private static List<DepartamentoTO> departamentos;
  private static List<PaisTO> paises;
  private static List<ProveedorTO> proveedores;
  private static List<AlmacenTO> almacenes;
  private static List<SubAlmacenTO> subalmacenes;
 private static List<SistemaTO> sistemas;
 private static List<FuncionRolTO> funciones;
 private static List<FuncionesAccessoUsuarioTO> funcionesacceso;
 private static IniciaSplash cargar;

 private static List<DatosUsuarioTO> datos_usuario= new ArrayList<DatosUsuarioTO>();
 private static List<TipoDatoTO> tipos_dato;
 private static List<DescripcionTiposTO> descripcion_tipos_dato;
 private static List<DescripcionTiposTO> descripcion_tipos_usuario;
 private static List<EmpresaTO> empresas;
 private static List<AlertaTO> alertas;
  private static List<GrupoSuministrosTO> grupospadre;
  private static List<ProveedorTO> cosechadores;
 private static Boolean Inventario=false;
 public static void cargarListas() throws Exception
  {      
            //cargar = new jdCargandoListas(null, true,13);
            try{
            cargar=new IniciaSplash();
            setInventario();
            cargar.avanzar("zonas");
            zonas = GestionPedidosDelegate.getInstance().getListaZonas();
            cargar.avanzar("localidades");
            localidades = GestionPedidosDelegate.getInstance().getListaLocalidades();
            cargar.avanzar("unidades organizativas");
            un_organizativa = GestionPedidosDelegate.getInstance().getListaUnidOrganizativas();
            cargar.avanzar("centro de costos");
            centro_costos = GestionPedidosDelegate.getInstance().getListaCentroCostos();
            cargar.avanzar("codigo presupuestal");
            cod_presupuestal = GestionPedidosDelegate.getInstance().getListaCodPresupuestal();
            cargar.avanzar("cuentas contables");
            cta_ctbles = GestionPedidosDelegate.getInstance().getListaCtaCbles();
            cargar.avanzar("codigos de inversion");
            cod_inversion = GestionPedidosDelegate.getInstance().getListaCodigoInversion();
            cargar.avanzar("tablas tipo");
            tipos = GestionPedidosDelegate.getInstance().getListaTipos();
            cargar.avanzar("parametros");
            parametros = GestionPedidosDelegate.getInstance().getListaParametrosLike("S");
            System.out.println("entro"+parametros.get(1).getParam2());
            cargar.avanzar("suministros");
            suministros= GestionPedidosDelegate.getInstance().getListaSuministros();
            cargar.avanzar("grupos suministros");
            gruposuministros= GestionPedidosDelegate.getInstance().getListaGrupoSuministros();
            cargar.avanzar("grupos suministros");
            grupospadre= GestionPedidosDelegate.getInstance().getListaGrupoSuministrosPadre();
            //anos = GestionPedidosDelegate.getInstance().getListaAnos();
            //cargar.avanzar("años");
            cargar.avanzar("meses");
            meses = GestionPedidosDelegate.getInstance().getListaMeses();
            cargar.avanzar("proyectos");
            proyectos=GestionPedidosDelegate.getInstance().getListaProyectos();
            cargar.avanzar("departamentos");
            departamentos=GestionPedidosDelegate.getInstance().listaDepartamentos();
            cargar.avanzar("paises");
            paises=GestionPedidosDelegate.getInstance().listaPais();
            cargar.avanzar("almacenes");
            almacenes=GestionPedidosDelegate.getInstance().getListaAlmacenes();
            cargar.avanzar("subalmacenes");
            subalmacenes= GestionPedidosDelegate.getInstance().getListaSubAlmacenes();
            cargar.avanzar("empresas");
            empresas= GestionPedidosDelegate.getInstance().obtenerEmpresas();
            cargar.avanzar("proveedores");
            proveedores=GestionPedidosDelegate.getInstance().listaProveedor();
            cargar.avanzar("cosechadores");
            cosechadores=GestionPedidosDelegate.getInstance().listaCosechador();
            cargar.avanzar("sistemas");
            sistemas= GestionSeguridadDelegate.getInstance().getListaSistema();
            cargar.avanzar("funciones");
            funciones= GestionSeguridadDelegate.getInstance().getListaFunciones();
            cargar.avanzar("datos_usuario");
            datos_usuario = GestionSeguridadDelegate.getInstance().getListaDatosUsuario(Propiedades.getUsuario());
            cargar.avanzar("accesos");
            funcionesacceso=GestionSeguridadDelegate.getInstance().getFuncionesAccesoUsuario(Propiedades.getUsuario());
            cargar.avanzar("tipos de dato");
            tipos_dato = GestionSeguridadDelegate.getInstance().getTiposDato();
            cargar.avanzar("descripcion tipos de dato");
            descripcion_tipos_dato = getDescripcionTiposDato();

            cargar.cierra();
          }catch(Exception e){
              e.printStackTrace();
          }finally{
              
          }
     
  }
   public static List<GrupoSuministrosTO> getGrupospadre() throws Exception{
        return grupospadre;
    }
 public static GrupoSuministrosTO getGrupoCodigo(String codigo) {
    GrupoSuministrosTO retorno = null;
    for (GrupoSuministrosTO sumi : gruposuministros) {
      if (sumi.getCodigo().equalsIgnoreCase(codigo)) {
        retorno = sumi;
        break;
      }
    }
    return retorno;
  }
    public static void setGrupospadre(List<GrupoSuministrosTO> grupospadre) {
        Listas.grupospadre = grupospadre;
    }
     public static List<GrupoSuministrosTO> getGruposuministros() {
        return gruposuministros;
    }

    public static void setGruposuministros(List<GrupoSuministrosTO> gruposuministros) {
        Listas.gruposuministros = gruposuministros;
    }
 //actualizarListas
    public static void cargarParametros() throws Exception{
       parametros = GestionPedidosDelegate.getInstance().getListaParametrosLike("S");
       
    }
     public static void cargarProveedor() throws Exception{
       proveedores = GestionPedidosDelegate.getInstance().listaProveedor();
    }
     public static void cargarEmpresas()  throws Exception{
       empresas= GestionPedidosDelegate.getInstance().obtenerEmpresas();
     }
      public static void cargarFunciones() throws Exception{
      funciones= GestionSeguridadDelegate.getInstance().getListaFunciones();
    }
       public static void cargarDatosUsuario() throws Exception{
      datos_usuario = GestionSeguridadDelegate.getInstance().getListaDatosUsuario(Propiedades.getUsuario());
    }
      public static void cargarAccesosUsuarios() throws Exception{
      funcionesacceso=GestionSeguridadDelegate.getInstance().getFuncionesAccesoUsuario(Propiedades.getUsuario());
    }
      public static void cargarTiposDatos() throws Exception{
        tipos_dato = GestionSeguridadDelegate.getInstance().getTiposDato();
      }
      public static void cargarPermisosUsuarios() throws Exception{
         descripcion_tipos_dato = getDescripcionTiposDato();
      }
     public static void cargarSuministros() throws Exception{
         suministros=GestionPedidosDelegate.getInstance().getListaSuministros();
      }
      public static void cargarGrupoSuministros() throws Exception{
         gruposuministros=GestionPedidosDelegate.getInstance().getListaGrupoSuministros();
      }
      public static void cargarTipos() throws Exception{
         tipos = GestionPedidosDelegate.getInstance().getListaTipos();
      }
       public static void cargarZonas() throws Exception{
         zonas = GestionPedidosDelegate.getInstance().getListaZonas();
         almacenes = GestionPedidosDelegate.getInstance().getListaAlmacenes();
         subalmacenes = GestionPedidosDelegate.getInstance().getListaSubAlmacenes();
       }
       public static void cargarCosechador() throws Exception{
           cosechadores=GestionPedidosDelegate.getInstance().listaCosechador();
       }
    public static Boolean getInventario() {
        return Inventario;
    }

    public static void setInventario() throws Exception {
        InventarioTO inv = GestionPedidosDelegate.getInstance().getDatosInventario();
            if (inv == null) {
               Listas.Inventario=false;
            } else {
               Listas.Inventario=true;
            }

    }
    public static InventarioTO retornaInventario() throws Exception{
        return GestionPedidosDelegate.getInstance().getDatosInventario();
    }


  public static void refrescarEmpresas() throws Exception{
      empresas= GestionPedidosDelegate.getInstance().obtenerEmpresas();
  }

   public static List<EmpresaTO> getEmpresasAll() {
        return empresas;
    }
   

    public static List<AlertaTO> getAlertas() throws Exception {
        return alertas;
    }
    public static List<AlertaTO> obtenerAlertas() throws Exception{
         try {
            List<suministros.ejb30.TO.SistemaTO> sistemasto = new ArrayList<suministros.ejb30.TO.SistemaTO>();
            for(seguridad.administracion.ejb30.TO.SistemaTO sistema : sistemas){
                suministros.ejb30.TO.SistemaTO sistemato = new suministros.ejb30.TO.SistemaTO();
                sistemato.setCodigo(sistema.getCodigo());
                sistemato.setDescripcion(sistema.getDescripcion());
                sistemasto.add(sistemato);
            }
            alertas=GestionPedidosDelegate.getInstance().obtenerAlertas(restringeEmpresaPorDatoUsuario(), restringeZonaPorDatoUsuario(), sistemasto);
        } catch (Exception ex) {
            Logger.getLogger(Listas.class.getName()).log(Level.SEVERE, null, ex);
        }
        
        return alertas;
    }
    public static int obtenerAlertasTamaño() throws Exception{
         List<suministros.ejb30.TO.SistemaTO> sistemasto = new ArrayList<suministros.ejb30.TO.SistemaTO>();
            for(seguridad.administracion.ejb30.TO.SistemaTO sistema : sistemas){
                suministros.ejb30.TO.SistemaTO sistemato = new suministros.ejb30.TO.SistemaTO();
                sistemato.setCodigo(sistema.getCodigo());
                sistemato.setDescripcion(sistema.getDescripcion());
                sistemasto.add(sistemato);
            }
        int tamaño=GestionPedidosDelegate.getInstance().obtenerAlertasTamaño(restringeEmpresaPorDatoUsuario(), restringeZonaPorDatoUsuario(), sistemasto);
        return tamaño;
    }

    public static void setAlertas(List<AlertaTO> alertas) {
        Listas.alertas = alertas;
    }

    public static List<EmpresaTO> getEmpresas() {
        List<EmpresaTO> empresasretorno= new ArrayList<EmpresaTO>(1);
        List<EmpresaTO> empresasAsignadas= restringeEmpresaPorDatoUsuario();
         for(EmpresaTO emp: empresasAsignadas)   {
             if(!emp.getPrincipal()){
                 empresasretorno.add(emp);
             }
                 
         }
           return empresasretorno;
    }
     public static List<EmpresaTO> getEmpresaPrincipal() {
          List<EmpresaTO> empresasretorno= new ArrayList<EmpresaTO>();
         List<EmpresaTO> empresasAsignadas= restringeEmpresaPorDatoUsuario();
         for(EmpresaTO emp: empresasAsignadas)   {
             if(emp.getPrincipal()){
                 empresasretorno.add(emp);
             }
         }

        return empresasretorno;
    }
    public static List<EmpresaTO> restringeEmpresaPorDatoUsuario(){
       List<EmpresaTO> retorno = new ArrayList(1);
       if(datos_usuario.isEmpty()){
           return empresas;
       }
       for(DatosUsuarioTO datos : datos_usuario){
               if(datos.getDescripcion_dato().equalsIgnoreCase("id_empresa")){
                   for(EmpresaTO e : empresas){
                        if(e.getCodigo().equalsIgnoreCase(datos.getValor_dato())){
                            retorno.add(e);
                        }
                   }
               }
       }
        if(retorno.isEmpty())
                        retorno=empresas;
       return retorno;
   }


    public static void setEmpresas(List<EmpresaTO> empresas) {
        Listas.empresas = empresas;
    }

  public static void refreshDatosUsuario(){
      try {
           datos_usuario = GestionSeguridadDelegate.getInstance().getListaDatosUsuario(Propiedades.getUsuario());
      } catch (Exception e) {
      }

  }

  public static  List<DescripcionTiposTO> getDescripcionTiposDeUsuario(String user) throws Exception{
      
       descripcion_tipos_usuario = GestionSeguridadDelegate.getInstance().getTiposDeUsuario(user);
       return setDescripcionTiposDeUsuario();
     
  }

   private static   List<DescripcionTiposTO> setDescripcionTiposDeUsuario(){
      
        for (DescripcionTiposTO ds : descripcion_tipos_usuario) {  
             for (DescripcionTiposTO d : descripcion_tipos_dato) {  
                  if (d.getTipo_dato().equalsIgnoreCase(ds.getTipo_dato()) && d.getId_descripcion_dato().equalsIgnoreCase(ds.getId_descripcion_dato())) {
                        ds.setDescripcion_dato(d.getDescripcion_dato());
                        //ds.setNom_tipo_dato(d.getNom_tipo_dato());          
                  }
            }
         
        }
        return  descripcion_tipos_usuario;
        
  }


   
  public static List<DescripcionTiposTO> getDescripcionTiposDato(){
      List<DescripcionTiposTO> retorno = new ArrayList(1);

     
              for(UnidadOrganizativaTO u : un_organizativa){
                        retorno.add(new DescripcionTiposTO(tipos_dato.get(1).getId_tipo(),tipos_dato.get(1).getNom_tipo(),u.getUnidad_organizativa(),u.getCod_Uni_Organizativa()));
                       
              }
              for(ProyectoTO p : proyectos){
                        retorno.add(new DescripcionTiposTO(tipos_dato.get(2).getId_tipo(),tipos_dato.get(2).getNom_tipo(),p.getNom_proyecto(),p.getId_proyecto()));
              }
              for(ZonaTO z : zonas){
                        retorno.add(new DescripcionTiposTO(tipos_dato.get(3).getId_tipo(),tipos_dato.get(3).getNom_tipo(),z.getNom_zona(),z.getId_zona()));
              }
              for(EmpresaTO e : empresas){
                        retorno.add(new DescripcionTiposTO(tipos_dato.get(4).getId_tipo(),tipos_dato.get(4).getNom_tipo(),e.getRazon(),e.getCodigo()));
              }
      return retorno;


  }
    public static List<ProyectoTO> obtenerProyectosPorEmpresa(String ruc_empresa){
      List<ProyectoTO> proyectoRetorno= new  ArrayList<ProyectoTO>();
      List<ProyectoTO> proyectoAsignados= restringeProyectoPorDatoUsuario();
      System.out.print("edede"+proyectoAsignados.get(0).getRuc_empresa());
      for(ProyectoTO proyecto:proyectoAsignados){
          if(proyecto.getRuc_empresa().compareTo(ruc_empresa)==0){
              proyectoRetorno.add(proyecto);

          }
      }
      return proyectoRetorno;
    }
  public static List<DescripcionTiposTO> getDescripcionTiposDatoPorId(String id){
      List<DescripcionTiposTO> retorno = new ArrayList(1);
        for (DescripcionTiposTO ds : descripcion_tipos_dato) {  
          if (ds.getTipo_dato().equalsIgnoreCase(id)) {
            retorno.add(ds);
          }
        }        
        return retorno;
  }

   public static List<TipoDatoTO>getTiposDato(){
        return tipos_dato;
   }

    public static List<FuncionesAccessoUsuarioTO> getFuncionesacceso() {
        return funcionesacceso;
    }
    public static List<FuncionesAccessoUsuarioTO> getFuncionesacceso(String idsistema) {
        List<FuncionesAccessoUsuarioTO> listafunciones= new ArrayList<FuncionesAccessoUsuarioTO>();
        for(FuncionesAccessoUsuarioTO funcion:funcionesacceso){
            if(funcion.getId_sistema().compareTo(idsistema)==0){
                listafunciones.add(funcion);
            }
        }
        return listafunciones;
    }

    public static void setFuncionesacceso(List<FuncionesAccessoUsuarioTO> funcionesacceso) {
        Listas.funcionesacceso = funcionesacceso;
    }

    public static List<CentroCostoTO> getCentro_costos() {
            return centro_costos;
  }
public static void cargarProveedores() throws Exception{
     proveedores=GestionPedidosDelegate.getInstance().listaProveedor();
}
  public static void cargarAnosMeses() throws Exception {
    anos = GestionPedidosDelegate.getInstance().getListaAnos();
    meses = GestionPedidosDelegate.getInstance().getListaMeses();
  }

  public static void cargarAnosMesesCambios() throws Exception {
    anos_cambio = GestionPedidosDelegate.getInstance().getListaAnosCambio();
    meses_cambio = GestionPedidosDelegate.getInstance().getListaMesCambio();
  }
  public static List<CentroCostoTO> getCentro_Costos_Unid_Organica(String cod_unidorg) {
    List<CentroCostoTO> lista_regreso = new ArrayList();
    for (CentroCostoTO cen_cos_aux :Listas.centro_costos) {
      if (cen_cos_aux.getCod_uni_Organizativa().trim().equalsIgnoreCase(cod_unidorg)) {          
          lista_regreso.add(cen_cos_aux);          
      }
    }
    return lista_regreso;
  }

  public static List<DetalleUsuarioSistemaTO> getDetallesUsuSistema() {
    return detallesUsuSistema;
  }

  public static void setDetallesUsuSistema(List<DetalleUsuarioSistemaTO> detallesUsuSistema1) {
    detallesUsuSistema = detallesUsuSistema1;
  }
  


 /* public static String getTipoUsuarioSistema(String loguser, Integer siste) {
    String ret = "";
    for (DetalleUsuarioSistemaTO deta : detallesUsuSistema) {
      if (deta.getId_sistema().equals(siste)) {
        ret = deta.getId_tipo_usuario().toString();
        break;
      }
    }

    return ret;
  }*/

  public static CentroCostoTO getCentro_Costos_codigo(String codcentrocostos) {
    CentroCostoTO cencos = null;
    for (CentroCostoTO centrocos : centro_costos) {
      if (centrocos.getCod_CentroCosto().equalsIgnoreCase(codcentrocostos)) {
        cencos = centrocos;
        break;
      }
    }
    return cencos;
  }
  public static void setCentro_costos(List<CentroCostoTO> centro_costos) {
    centro_costos = centro_costos;
  }

  public static List<CodigosInversionTO> getCod_inversion() {
    return cod_inversion;
  }

  public static CodigosInversionTO getCodigoInversionCodigo(String cod) {
    CodigosInversionTO codpre = null;
    for (CodigosInversionTO codpre_p : cod_inversion) {
      if (codpre_p.getId_cod_inversion().equalsIgnoreCase(cod)) {
        codpre = codpre_p;
        break;
      }
    }
    return codpre;
  }
  public static void setCod_inversion(List<CodigosInversionTO> cod_inversion) {
    cod_inversion = cod_inversion;
  }

  public static List<CodPresupuestalTO> getCod_presupuestal() {
    return cod_presupuestal;
  }

  public static CodPresupuestalTO getCod_presupuestal_codigo(String codpres) {
    CodPresupuestalTO codpre = null;
    for (CodPresupuestalTO codpre_p : cod_presupuestal) {
      if (codpre_p.getId_cod_presupuestal().equalsIgnoreCase(codpres)) {
        codpre = codpre_p;
        break;
      }
    }
    return codpre;
  }
  public static void setCod_presupuestal(List<CodPresupuestalTO> cod_presupuestal) {
    cod_presupuestal = cod_presupuestal;
  }

  public static List<CuentaContableTO> getCta_ctbles() {
    return cta_ctbles;
  }

  public static void setCta_ctbles(List<CuentaContableTO> cta_ctbles) {
    cta_ctbles = cta_ctbles;
  }

  public static CuentaContableTO getCtaCbleCodigo(String codigo) {
    CuentaContableTO retorno = null;
    for (CuentaContableTO cta : cta_ctbles) {
      if (cta.getIdCuentaContable().equalsIgnoreCase(codigo)) {
        retorno = cta;
        break;
      }
    }
    return retorno;
  }
  public static List<TipoTO> getTipos() {
    return tipos;
  }

  public static List<TipoTO> getTipo_porTabla(String tabla) {
    List lista = new ArrayList(1);
    for (TipoTO tipp : tipos) {
      if (tipp.getTabla().trim().equalsIgnoreCase(tabla)) {
        lista.add(tipp);
      }
    }
    return lista;
  }

   public static TipoTO getTipo_porId(Integer id) {
    TipoTO tip = null;
    for (TipoTO tipp : tipos) {
      if (tipp.getId_tabla_tipo().equals(id)) {
        tip = tipp;
        break;
      }
    }
    return tip;
  }
 public static TipoTO getTipo_porNombre(String id) {
    TipoTO tip = null;
    for (TipoTO tipp : tipos) {
      if(tipp.getDescripcion_campo().compareTo("Tipo_Salida")==0){
          if (tipp.getDescripcion_valor().substring(0,4).equalsIgnoreCase(id)) {
            tip = tipp;
            break;
          }
      }
    }
    return tip;
  }
  public static void setTipos(List<TipoTO> tipos) {
    tipos = tipos;
  }

  public static List<UnidadOrganizativaTO> getUn_organizativa() {
    return restringeUnidadOrganizativaPorDatoUsuario();
  }

   public static List<UnidadOrganizativaTO> restringeUnidadOrganizativaPorDatoUsuario(){
       List<UnidadOrganizativaTO> retorno = new ArrayList(1);
       if(datos_usuario.isEmpty()){
           return un_organizativa;
       }
       for(DatosUsuarioTO datos : datos_usuario){
               if(datos.getDescripcion_dato().equalsIgnoreCase("cod_Uni_Organizativa")){
                   for(UnidadOrganizativaTO u : un_organizativa){
                        if(u.getCod_Uni_Organizativa().equalsIgnoreCase(datos.getValor_dato())){
                            retorno.add(u);
                        }
                   }

               }
       }
        if(retorno.isEmpty())
                        retorno=un_organizativa;
       return retorno;
   }


  public static void setUn_organizativa(List<UnidadOrganizativaTO> un_organizativa) {
    un_organizativa = un_organizativa;
  }
  public static UnidadOrganizativaTO getUn_organizativa_codigo(String codunorg) {
    UnidadOrganizativaTO unid = null;
    List<UnidadOrganizativaTO> tmp = restringeUnidadOrganizativaPorDatoUsuario();
    for (UnidadOrganizativaTO unid_org : tmp) {
      if (unid_org.getCod_Uni_Organizativa().equalsIgnoreCase(codunorg)) {
        unid = unid_org;
        break;
      }
    }
    return unid;
  }
  public static List<UnidadOrganizativaTO> getUn_organizativa_Dependientes(UnidadOrganizativaTO unorg) {
    List<UnidadOrganizativaTO> unid = new ArrayList(1);
    unid.add(unorg);
    for (UnidadOrganizativaTO unid_org : un_organizativa) {
      if (unid_org.getCod_Uni_Depend().equalsIgnoreCase(unorg.getCod_Uni_Organizativa()) && Integer.parseInt(unid_org.getNivel())>2) {
        unid.add(unid_org);
      }
    }
    return unid;
  }


  public static void setZonas(List<ZonaTO> zon) {
    zonas = zon;
  }

  public static List<ZonaTO> getZonas() {
    return restringeZonaPorDatoUsuario();
      /*zonas.clear();
      ZonaTO s= new ZonaTO();
      s.setId_zona("01");
      s.setNom_zona("ZONAL PIURA");
      zonas.add(s);
      ZonaTO s1= new ZonaTO();
      s1.setId_zona("04");
      s1.setNom_zona("ZONAL CHULUCANAS");
      zonas.add(s1);
      return zonas;*/


  }
 
   public static List<ZonaTO> restringeZonaPorDatoUsuario(){
       List<ZonaTO> retorno = new ArrayList(1);
        if(datos_usuario.isEmpty()){
           return zonas;
       }
       for(DatosUsuarioTO datos : datos_usuario){
               if(datos.getDescripcion_dato().trim().equalsIgnoreCase("id_zona")){
                 
                   for(ZonaTO z : zonas){
                        if(z.getId_zona().equalsIgnoreCase(datos.getValor_dato().trim())){
                            
                            retorno.add(z);
                        }
                   }
               }   
       }
         if(retorno.isEmpty())
                        retorno=zonas;
       return retorno;
   }

  public static ZonaTO getZonaCodigo(String codigo) {
    ZonaTO retorno = null;
    for (ZonaTO zona : zonas) {
      if (zona.getId_zona().equalsIgnoreCase(codigo)) {
        retorno = zona;
        break;
      }
    }
    return retorno;
  }

  public static EmpresaTO getEmpresaCodigo(String codigo) {
    EmpresaTO retorno = null;
    for (EmpresaTO empresa : empresas) {
      if (empresa.getCodigo().equalsIgnoreCase(codigo)) {
        retorno = empresa;
        break;
      }
    }
    return retorno;
  }


  public static void setLocalidades(List<LocalidadTO> loc) {
    localidades = loc;
  }

  public static List<LocalidadTO> getLocalidades() {
    return localidades;
  }

  public static List<Parametros> getParametros() {
    return parametros;
  }

  public  void setParametros(List<Parametros> parametros) {
    this.parametros = parametros;
  }

  public static List<SuministroTO> getSuministros() {
    return suministros;
  }

  public static List<SuministroTO> getSuministrosParaCompra() {
        List<SuministroTO> sumi_compra = new ArrayList<SuministroTO>(1);
      for (SuministroTO s : suministros) {
           int a;
          try{
              a = s.getTipo_suministro().intValue();
          }catch(Exception e){
              a=0;
          }
          if(a==1 || a==3 )
              sumi_compra.add(s);
      }
      return sumi_compra;
  }

  public static List<SuministroTO> getSuministrosParaServicio() {
        List<SuministroTO> sumi_servicio = new ArrayList<SuministroTO>(1);
      for (SuministroTO s : suministros) {
           int a;
          try{
              a = s.getTipo_suministro().intValue();
          }catch(Exception e){
              a=0;
          }

          if(a==2)
              sumi_servicio.add(s);
      }
      return sumi_servicio;
  }

  public static void setSuministros(List<SuministroTO> suministros) {
    suministros = suministros;
  }

    public static List<AlmacenTO> getAlmacenes() {
        return almacenes;
    }

    public static void setAlmacenes(List<AlmacenTO> almacenes) {
        Listas.almacenes = almacenes;
    }

    public static List<SubAlmacenTO> getSubalmacenes() {
        return subalmacenes;
    }

    public static void setSubalmacenes(List<SubAlmacenTO> subalmacenes) {
        Listas.subalmacenes = subalmacenes;
    }

  public static List<LocalidadTO> getLocalidadZona(ZonaTO zon) throws Exception
  {
    List lista = new ArrayList(1);
    for (LocalidadTO loca : localidades) {
      if (loca.getId_zona().trim().equalsIgnoreCase(zon.getId_zona().trim())) {
        lista.add(loca);
      }
    }
    return lista;
  }

  public static List<AlmacenTO> getAlmacenEnZona(ZonaTO zon)throws Exception{
    List lista = new ArrayList(1);
   
    for (AlmacenTO alm : almacenes) {
        
      if (alm.getId_zona().trim().equalsIgnoreCase(zon.getId_zona().trim())) {
        lista.add(alm);
      }
    }
    return lista;
  }

  public static List<SubAlmacenTO> getSubAlmacenEnAlmacen(AlmacenTO alm)throws Exception{
    List lista = new ArrayList(1);
    for (SubAlmacenTO sb_alm : subalmacenes) {
      if (sb_alm.getCodAlmacen().trim().equalsIgnoreCase(alm.getCodAlmacen().trim())) {
        lista.add(sb_alm);
      }
    }
    return lista;
  }

  public static Parametros getParametrosID(String id) throws Exception {
    Parametros retorno = null;
    for (Parametros param : parametros) {
      if (param.getIdParametro().equalsIgnoreCase(id)) {
        retorno = param;
        break;
      }
    }
    return retorno;
  }

  public static List<Parametros> getParametrosLikeId(String id) throws Exception {
    List retorno = new ArrayList(1);
    for (Parametros param : parametros) {
      if (param.getIdParametro().startsWith(id)) {
        retorno.add(param);
      }
    }
    return retorno;
  }

  public static SuministroTO getSuministroCodigo(String codigo) {
    SuministroTO retorno = null;
    for (SuministroTO sumi : suministros) {
      if (sumi.getId_suministro().equalsIgnoreCase(codigo)) {
        retorno = sumi;
        break;
      }
    }
    return retorno;
  }
   public static SuministroTO getSuministroDescripcion(String descripcion) {
    SuministroTO retorno = null;
    for (SuministroTO sumi : suministros) {
      if (sumi.getDescripcion().equalsIgnoreCase(descripcion)) {
        retorno = sumi;
        break;
      }
    }
    return retorno;
  }

  public static List<AnoTO> getAnos() {
    return anos;
  }

   public static List<AnoTO> getAnosCambio() {
    return anos_cambio;
  }

  public static void setAnos(List<AnoTO> anos) {
    anos = anos;
  }

  public static List<MesTO> getMeses() {
    return meses;
  }

   public static List<MesTO> getMesesCambio() {
    return meses_cambio;
  }

  public static List<MesTO> getMesesAno(AnoTO an) {
    List retorno = new ArrayList(1);
    for (MesTO mes : meses) {
      if (mes.getAno().equalsIgnoreCase(an.getAno())) {
        retorno.add(mes);
      }
    }
    return retorno;
  }

   public static List<MesTO> getMesesAnoCambios(AnoTO an) {
    List retorno = new ArrayList(1);
    for (MesTO mes : meses_cambio) {
      if (mes.getAno().equalsIgnoreCase(an.getAno())) {
        retorno.add(mes);
      }
    }
    return retorno;
  }

  public static void setMeses(List<MesTO> meses) {
    meses = meses;
  }

    public static List<ProyectoTO> getProyectos() {
        return restringeProyectoPorDatoUsuario();
    }

     public static List<ProyectoTO> restringeProyectoPorDatoUsuario(){
       List<ProyectoTO> retorno = new ArrayList(1);
        if(datos_usuario.isEmpty()){
           return proyectos;
       }
       for(DatosUsuarioTO datos : datos_usuario){
               if(datos.getDescripcion_dato().trim().equalsIgnoreCase("id_proyecto")){
                   for(ProyectoTO p : proyectos){
                        if(p.getId_proyecto().equalsIgnoreCase(datos.getValor_dato().trim())){
                            retorno.add(p);
                        }
                   } 
               }
       }
         if(retorno.isEmpty())
                        retorno=proyectos;
       return retorno;
   }

    public static void setProyectos(List<ProyectoTO> proyectos) {
        Listas.proyectos = proyectos;
    }

  public static ProyectoTO getProyectoCodigo(String codigo) {
    ProyectoTO retorno = null;
    List<ProyectoTO> tmp = restringeProyectoPorDatoUsuario();
    for (ProyectoTO proy : tmp) {
      if (proy.getId_proyecto().equalsIgnoreCase(codigo)) {
        retorno = proy;
        break;
      }
    }
    return retorno;
  }
  public static List<DepartamentoTO> getDepartamentos() {
    return departamentos;
  }
public static List<PaisTO> getPaises() {
    return paises;
  }
public static List<ProveedorTO> getProveedores() {
    return proveedores;
  }
public static ProveedorTO getProveedorcodigo(String cod) {
    ProveedorTO unid = null;
    for (ProveedorTO unid_pro : proveedores) {
      if (unid_pro.getCodProveedor().equalsIgnoreCase(cod)) {
        unid = unid_pro;
        break;
      }
    }
    return unid;
  }
public static ProveedorTO getProveedorRazon(String razon) {
    ProveedorTO unid = null;
    for (ProveedorTO unid_pro : proveedores) {     
      if (unid_pro.getRazon().equalsIgnoreCase(razon)) {
        System.out.println("razon222"+unid_pro.getRazon());
        unid = unid_pro;
        break;
      }
    }
    return unid;
  }
public static ProveedorTO getCosechadorRazon(String razon) {
    ProveedorTO unid = null;
    for (ProveedorTO unid_pro : cosechadores) {
      if (unid_pro.getRazon().equalsIgnoreCase(razon)) {
        unid = unid_pro;
        break;
      }
    }
    return unid;
  }
public static AlmacenTO getAlmacenCodigo(String cod) {
    AlmacenTO unid = null;
    for (AlmacenTO unid_pro : almacenes) {
      if (unid_pro.getDescripcion().equalsIgnoreCase(cod)) {
        unid = unid_pro;
        break;
      }
    }
    return unid;
  }
public static SubAlmacenTO getSubAlmacenCodigo(String cod) {
    SubAlmacenTO unid = null;
    for (SubAlmacenTO unid_pro : subalmacenes) {
      if (unid_pro.getDescripcion().equalsIgnoreCase(cod)) {
        unid = unid_pro;
        break;
      }
    }
    return unid;
  }
 

 
 
  public static TipoTO getTipo_porTablaYCodigo(String tabla,String codigo) {
    TipoTO obj = new TipoTO();
    for (TipoTO tipp : tipos) {
      if (tipp.getTabla().trim().equalsIgnoreCase(tabla) && tipp.getCodigo().trim().equalsIgnoreCase(codigo) ) {
        obj=tipp;
      }
    }
    return obj;
  }
  public static List<SistemaTO> getSistemas() {
    return sistemas;
  }

  public static void setSistema(List<SistemaTO> detallesistema) {
    sistemas = detallesistema;
  }
   public static List<FuncionRolTO> getFunciones() {
    return funciones;
  }

  public static void setFunciones(List<FuncionRolTO> detallesfuncion) {
    funciones = detallesfuncion;
  }
 public static List<FuncionRolTO> getFuncion_sistema(String sistema) {
    List lista = new ArrayList(1);
    for (FuncionRolTO tipp : funciones) {
      if (tipp.getSistema().trim().equalsIgnoreCase(sistema)) {
        lista.add(tipp);
      }
    }
    return lista;
  }

 public static List<DatosUsuarioTO> getDatosUsuario(){
     return datos_usuario;
 }

    public static List<ProveedorTO> getCosechadores() {
        return cosechadores;
    }

    public static void setCosechadores(List<ProveedorTO> cosechadores) {
        Listas.cosechadores = cosechadores;
    }
 

}
